
import main from "../dbs/main.db";
import { http } from 'system';

/**
 * 获取分析结构分页列表
 * @param {number} [contentId] - 内容ID筛选（可选）
 * @param {string} [type] - 分析类型筛选（可选）
 * @param {number} [page=1] - 页码（默认1）
 * @param {number} [pageSize=10] - 每页数量（默认10）
 * @param {string} [searchKeyword=''] - 搜索关键词（可选），搜索范围包括：事件、要点、关键词
 * @returns {Object} 标准响应格式 {code:number, message:string, data:{list:Array<{id:number, content_id:number, keyword:string, content_point:string, content_event:string, keyword_weight:number, content_point_weight:number, content_event_weight:number, create_at:string, modify_at:string}>, total:number, page:number, pageSize:number}}
 * @example
 * // 使用示例
 * const result = await getAnalysisList(123, 'keyword', 1, 10, '搜索词');
 * 
 * @clientCall iToolX.modules.analysisManager.getAnalysisList()
 * 
 * // 完整的result数据结构说明
 * {
 *   code: 200,
 *   message: '',
 *   data: {
 *     list: [
 *       {
 *         id: 1,
 *         content_id: 123,
 *         keyword: "示例关键词",
 *         content_point: "示例观点",
 *         content_event: "示例事件",
 *         keyword_weight: 80,
 *         content_point_weight: 70,
 *         content_event_weight: 60,
 *         create_at: "2023-01-01T00:00:00Z",
 *         modify_at: "2023-01-02T00:00:00Z"
 *       }
 *     ],
 *     total: 100,
 *     page: 1,
 *     pageSize: 10
 *   }
 * }
 */
async function getAnalysisList(contentId, type, page = 1, pageSize = 10, searchKeyword = '') {
    try {
        const queryParams = {
            "total@": "crawl_site_content_analysis[]/total",
            "crawl_site_content_analysis[]": {
                page,
                count: pageSize,
                query: 2,
                "@order": "create_at-"
            }
        };

        // 添加内容ID筛选条件
        if (contentId) {
            queryParams["crawl_site_content_analysis[]"]["content_id"] = contentId;
        }

        // 添加分析类型筛选条件
        if (type) {
            switch (type) {
                case 'keyword':
                    queryParams["crawl_site_content_analysis[]"]["keyword!"] = "";
                    break;
                case 'point':
                    queryParams["crawl_site_content_analysis[]"]["content_point!"] = "";
                    break;
                case 'event':
                    queryParams["crawl_site_content_analysis[]"]["content_event!"] = "";
                    break;
            }
        }

        // 添加搜索关键词条件，搜索范围包括：事件、要点、关键词
        if (searchKeyword) {
            queryParams["crawl_site_content_analysis[]"]["@or"] = {
                "keyword$": `%${searchKeyword}%`,
                "content_point$": `%${searchKeyword}%`,
                "content_event$": `%${searchKeyword}%`
            };
        }

        const result = await main.queryAsync(queryParams);

        return {
            code: 200,
            message: '',
            data: {
                list: result.crawl_site_content_analysis || [],
                total: result.total || 0,
                page,
                pageSize
            }
        };
    } catch (error) {
        console.error('获取分析结构列表失败:', error);
        return {
            code: 500,
            message: '获取分析结构列表失败',
            data: error.message
        };
    }
}

/**
 * 添加分析结构
 * @param {number} contentId - 内容ID
 * @param {string} type - 分析类型（keyword/point/event）
 * @param {Object} data - 分析数据
 * @param {string} [data.keyword] - 关键词（当type为keyword时）
 * @param {string} [data.content_point] - 观点（当type为point时）
 * @param {string} [data.content_event] - 事件（当type为event时）
 * @param {number} [data.keyword_weight] - 关键词权重（1-100）
 * @param {number} [data.content_point_weight] - 观点权重（1-100）
 * @param {number} [data.content_event_weight] - 事件权重（1-100）
 * @returns {Object} 标准响应格式 {code:number, message:string, data:{id:number}}
 * @example
 * // 使用示例
 * const result = await addAnalysis(123, 'keyword', { keyword: "示例", keyword_weight: 80 });
 * 
 * @clientCall iToolX.modules.analysisManager.addAnalysis()
 * 
 * // 完整的result数据结构说明
 * {
 *   code: 200,
 *   message: '添加成功',
 *   data: {
 *     id: 1
 *   }
 * }
 */
async function addAnalysis(contentId, type, data) {
    try {
        const analysisData = {
            content_id: contentId,
            create_at: new Date().toISOString(),
            modify_at: new Date().toISOString()
        };

        // ??据分析类型设置相应字段
        switch (type) {
            case 'keyword':
                analysisData.keyword = data.keyword || '';
                analysisData.keyword_weight = data.keyword_weight || 50;
                break;
            case 'point':
                analysisData.content_point = data.content_point || '';
                analysisData.content_point_weight = data.content_point_weight || 50;
                break;
            case 'event':
                analysisData.content_event = data.content_event || '';
                analysisData.content_event_weight = data.content_event_weight || 50;
                break;
            default:
                return {
                    code: 400,
                    message: '无效的分析类型',
                    data: null
                };
        }

        const id = await main.addAsync({
            "crawl_site_content_analysis": analysisData
        });

        return {
            code: 200,
            message: '添加成功',
            data: { id }
        };
    } catch (error) {
        console.error('添加分析结构失败:', error);
        return {
            code: 500,
            message: '添加分析结构失败',
            data: error.message
        };
    }
}

/**
 * 更新分析结构
 * @param {number} id - 分析结构ID
 * @param {string} type - 分析类型（keyword/point/event）
 * @param {Object} data - 分析数据
 * @param {string} [data.keyword] - 关键词（当type为keyword时）
 * @param {string} [data.content_point] - 观点（当type为point时）
 * @param {string} [data.content_event] - 事件（当type为event时）
 * @param {number} [data.keyword_weight] - 关键词权重（1-100）
 * @param {number} [data.content_point_weight] - 观点权重（1-100）
 * @param {number} [data.content_event_weight] - 事件权重（1-100）
 * @returns {Object} 标准响应格式 {code:number, message:string, data:null}
 * @example
 * // 使用示例
 * const result = await updateAnalysis(1, 'keyword', { keyword: "更新后的关键词", keyword_weight: 90 });
 * 
 * @clientCall iToolX.modules.analysisManager.updateAnalysis()
 * 
 * // 完整的result数据结构说明
 * {
 *   code: 200,
 *   message: '更新成功',
 *   data: null
 * }
 */
async function updateAnalysis(id, type, data) {
    try {
        // 首先检查记录是否存在
        const checkResult = await main.queryAsync({
            "crawl_site_content_analysis": {
                id
            }
        });

        if (!checkResult.crawl_site_content_analysis?.id) {
            return {
                code: 404,
                message: '分析结构不存在',
                data: null
            };
        }

        const updateData = {
            id,
            modify_at: new Date().toISOString()
        };

        // 根据分析类型设置相应字段
        switch (type) {
            case 'keyword':
                updateData.keyword = data.keyword;
                if (data.keyword_weight !== undefined) {
                    updateData.keyword_weight = data.keyword_weight;
                }
                break;
            case 'point':
                updateData.content_point = data.content_point;
                if (data.content_point_weight !== undefined) {
                    updateData.content_point_weight = data.content_point_weight;
                }
                break;
            case 'event':
                updateData.content_event = data.content_event;
                if (data.content_event_weight !== undefined) {
                    updateData.content_event_weight = data.content_event_weight;
                }
                break;
            default:
                return {
                    code: 400,
                    message: '无效的分析类型',
                    data: null
                };
        }

        await main.modifyAsync({
            "crawl_site_content_analysis": updateData
        });

        return {
            code: 200,
            message: '更新成功',
            data: null
        };
    } catch (error) {
        console.error('更新分析结构失败:', error);
        return {
            code: 500,
            message: '更新分析结构失败',
            data: error.message
        };
    }
}

/**
 * 删除分析结构
 * @param {number} id - 分析结构ID
 * @returns {Object} 标准响应格式 {code:number, message:string, data:null}
 * @example
 * // 使用示例
 * const result = await deleteAnalysis(1);
 * 
 * @clientCall iToolX.modules.analysisManager.deleteAnalysis()
 * 
 * // 完整的result数据结构说明
 * {
 *   code: 200,
 *   message: '删除成功',
 *   data: null
 * }
 */
async function deleteAnalysis(id) {
    try {
        // 首先检查记录是否存在
        const checkResult = await main.queryAsync({
            "crawl_site_content_analysis": {
                id
            }
        });

        if (!checkResult.crawl_site_content_analysis?.id) {
            return {
                code: 404,
                message: '分析结构不存在',
                data: null
            };
        }

        await main.removeAsync({
            "crawl_site_content_analysis": {
                id
            }
        });

        return {
            code: 200,
            message: '删除成功',
            data: null
        };
    } catch (error) {
        console.error('删除分析结构失败:', error);
        return {
            code: 500,
            message: '删除分析结构失败',
            data: error.message
        };
    }
}

/**
 * 获取分析统计数据
 * @param {number} [contentId] - 内容ID筛选（可选），如果提供则只统计该内容ID的分析数据
 * @param {number} [sourceId] - 抓取源ID筛选（可选）
 * @param {string} [startDate] - 开始日期（格式：YYYY-MM-DD）
 * @param {string} [endDate] - 结束日期（格式：YYYY-MM-DD）
 * @returns {Object} 标准响应格式 {code:number, message:string, data:{stats:{totalAnalysis:number, keywordAnalysis:number, pointAnalysis:number, eventAnalysis:number, avgKeywordWeight:number, avgPointWeight:number, avgEventWeight:number}}}
 * @example
 * // 使用示例
 * const result = await getAnalysisStats(123, null, '2023-01-01', '2023-12-31');
 * 
 * @clientCall iToolX.modules.analysisManager.getAnalysisStats()
 * 
 * // 完整的result数据结构说明
 * {
 *   code: 200,
 *   message: '',
 *   data: {
 *     stats: {
 *       totalAnalysis: 100,
 *       keywordAnalysis: 40,
 *       pointAnalysis: 30,
 *       eventAnalysis: 30,
 *       avgKeywordWeight: 0.75,
 *       avgPointWeight: 0.65,
 *       avgEventWeight: 0.70
 *     }
 *   }
 * }
 */
async function getAnalysisStats(contentId, sourceId, startDate, endDate) {
    try {
        // 构建基础查询条件
        let queryConditions = {};

        // 添加日期范围筛选
        if (startDate && endDate) {
            queryConditions["create_at&{}"] = `>=${startDate} 00:00:00,<=${endDate} 23:59:59`;
        }

        let analysisList = [];

        // 如果指定了内容ID，直接使用内容ID筛选
        if (contentId) {
            queryConditions["content_id"] = contentId;
            const result = await main.queryAsync({
                "crawl_site_content_analysis[]": {
                    ...queryConditions,
                    count: -1
                }
            });
            analysisList = result.crawl_site_content_analysis || [];
        }
        // 如果指定了抓取源ID，需要关联查询内容表
        else if (sourceId) {
            const result = await main.queryAsync({
                "[]": {
                    "crawl_site_content_analysis": {
                        ...queryConditions
                    },
                    "crawl_site_content": {
                        "id@": "crawl_site_content_analysis/content_id",
                        "source_id": sourceId
                    }
                }
            });
            analysisList = result["[]"] || [];
        } else {
            // 直接查询分析表
            const result = await main.queryAsync({
                "crawl_site_content_analysis[]": {
                    ...queryConditions,
                    count: -1
                }
            });
            analysisList = result.crawl_site_content_analysis || [];
        }

        return calculateStats(analysisList);
    } catch (error) {
        console.error('获取分析统计数据失败:', error);
        return {
            code: 500,
            message: '获取分析统计数据失败',
            data: error.message
        };
    }
}

/**
 * 计算统计数据的辅助函数
 * @param {Array} analysisList - 分析结构列表
 * @returns {Object} 统计结果
 */
function calculateStats(analysisList) {
    const stats = {
        totalAnalysis: analysisList.length,
        keywordAnalysis: 0,
        pointAnalysis: 0,
        eventAnalysis: 0,
        totalKeywordWeight: 0,
        totalPointWeight: 0,
        totalEventWeight: 0,
        keywordCount: 0,
        pointCount: 0,
        eventCount: 0
    };

    analysisList.forEach(item => {
        // 检查关键词是否存在且不为空
        if (item.keyword && item.keyword.trim() !== '') {
            stats.keywordAnalysis++;
            stats.totalKeywordWeight += item.keyword_weight || 50;
            stats.keywordCount++;
        }

        // 检查观点是否存在且不为空
        if (item.content_point && item.content_point.trim() !== '') {
            stats.pointAnalysis++;
            stats.totalPointWeight += item.content_point_weight || 50;
            stats.pointCount++;
        }

        // 检查事件是否存在且不为空
        if (item.content_event && item.content_event.trim() !== '') {
            stats.eventAnalysis++;
            stats.totalEventWeight += item.content_event_weight || 50;
            stats.eventCount++;
        }
    });

    // 计算平均权重（将1-100的范围转换为0-1的范围）
    stats.avgKeywordWeight = stats.keywordCount > 0 ? (stats.totalKeywordWeight / stats.keywordCount) / 100 : 0;
    stats.avgPointWeight = stats.pointCount > 0 ? (stats.totalPointWeight / stats.pointCount) / 100 : 0;
    stats.avgEventWeight = stats.eventCount > 0 ? (stats.totalEventWeight / stats.eventCount) / 100 : 0;

    // 删除中间计算字段
    delete stats.totalKeywordWeight;
    delete stats.totalPointWeight;
    delete stats.totalEventWeight;
    delete stats.keywordCount;
    delete stats.pointCount;
    delete stats.eventCount;

    return {
        code: 200,
        message: '',
        data: {
            stats
        }
    };
}

// 导出所有方法
export {
    getAnalysisList,
    addAnalysis,
    updateAnalysis,
    deleteAnalysis,
    getAnalysisStats
};